package stream.demo02;
//中间操作

import java.util.ArrayList;
import java.util.stream.Stream;

/**
 * Stream<T> filter(Predicate predicate)：用于对流中的数据进行过滤，
 * Predicate接口中的方法boolean test(T t)对给定的参数进行判断，返回一个布尔值
 * Stream<T> limit(long maxSize)返回此流中的元素组成的流，截取前指定参数个数的数据
 * Stream<T> skip(long n)跳过指定参数个数的数据，返回由该流的剩余元素组成 的流
 * static <T> Stream<T> concat(Stream a, Stream b)合并a和b两个流为一个流
 * Stream<T> distinct()返回由该流的不同元素（根据Object.equals(Object)）组成的流
 * Stream<T> sorted()返回由此流的元素组成的流，根据自然顺序排序
 * Stream<T> sorted(Comparator comparator)返回由该流的元素组成的流，根据提供的Comparator进行排序
 */
public class StreamDemo01 {

    //入口
    public static void main(String[] args) {
        //创建一个ArraryList集合
        ArrayList<Integer> arrayList = new ArrayList<>();

        //添加元素
        arrayList.add(23);
        arrayList.add(45);
        arrayList.add(78);
        arrayList.add(90);
        arrayList.add(90);
        arrayList.add(100);

        //创建Stream流
        //需求获取大于等于78的元素，并进行遍历，通过Stream流完成
        arrayList.stream().filter(s -> {
                    if (s >= 78) {
                        return true;
                    } else {
                        return false;
                    }
                }
        ).forEach(s -> System.out.println(s));
        System.out.println("---------------");

        //Stream<T> limit(long maxSize)返回此流中的元素组成的流，截取前指定参数个数的数据
        arrayList.stream().limit(4).forEach(s -> System.out.println(s));

        System.out.println("----------------");
        // Stream<T> skip(long n)跳过指定参数个数的数据，返回由该流的剩余元素组成的流
        arrayList.stream().skip(2).forEach(s -> System.out.println(s));

        System.out.println("----------------");
        // static <T> Stream<T> concat(Stream a, Stream b)合并a和b两个流为一个流
        //创建新的集合并添加元素
        ArrayList<Integer> arrayList1 = new ArrayList<>();
        arrayList1.add(34);
        arrayList1.add(78);
        arrayList1.add(19);
        arrayList1.add(100);
        //合并两个集合
        Stream<Integer> stream = Stream.concat(arrayList.stream(), arrayList1.stream());

        // stream.forEach(s-> System.out.println(s));

        System.out.println("------------");
        //Stream<T> distinct()返回由该流的不同元素（根据Object.equals(Object)）组成的流
        //stream.distinct().forEach(s-> System.out.println(s));

        System.out.println("------------");
        //Stream<T> sorted()返回由此流的元素组成的流，根据自然顺序排序
        //stream.sorted().distinct().forEach(s-> System.out.println(s));

        System.out.println("------------");
        //Stream<T> sorted(Comparator comparator)返回由该流的元素组成的流，根据提供的Comparator进行排序
        stream.distinct().sorted((s1, s2) -> s2 - s1).forEach(s -> System.out.println(s));


    }
}
